Appendix: Uniication Algorithm 5.4 Irrefutable Patterns 5.1 Overloading 5.2 Preserving Polymorphism 4.4 Instances of a Polymorphic Type 4.3 Type Checking an Instruction Sequence 4.1 Type Structure 4.2 Type Interpretation 4 Types for Terms Polymorphic Type Checking by Interpretation of Code

In the text, the function unify was used several times, but it has not been deened yet. As mentioned, we need just ordinary rst-order uniication, so we give its deenition here for the sake of completeness. The algorithm uses a simple divide-and-conquer strategy, i.e. it uniies two terms by unifying their subterms and composing the resulting uniiers. unify x (Tvar n) = unify (Tvar n) x unify (Tcon s tl) (Tcon s' tl') = foldr comp (True,,]) (zipWith unify tl tl'), if s=s' unify p q = (False, undef), otherwise zipWith f (a:as) (b:bs) = f a b : zipWith f as bs zipWith f x y = ] The function unify does proper uniication, comp tries to compose the uniiers of the subproblems. It is assumed that each type constructor s has a xed arity a s , i.e. for any (Tcon s ls) the list ls has length a s. This assumption is not really necessary for rst-order uniication, but it is simply true for the languages with which we are concerned. occur n (Tvar m) = n=m occur n (Tcon f ls) = t|t<-ls; occur n t] ~= ] Ordinary uniication of rst order terms requires an occur check, here performed by the function occur. It would be no problem to enrich the approach to cyclic types, i.e. to use trees with nitely many diierent subtrees instead of nite trees, but this is beyond the scope of this paper and is of no signiicance for the approach. comp (True,x)(True,y) = foldr comp1 (True,x) y comp x y = (False,undef), otherwise comp1 x (False,y) = (False,undef) comp1 (n,t) (True,s) = comp (unify t (hd ua)) (True,s), if ua~==] = (True,s), if t'=Tvar n = (False,undef), if occur n t' = (True,(n,t'):s'), otherwise where ua = lookup n s t' = subst s t s' = subst_assoc (n,t')] s The function comp composes two uniiers. An occur check (for comp1) is necessary again, because the type t, the substitute for n, might contain a type variable m, which might be substituted in (True,s) by a type u, which again might contain the type variable n. lookup lab ls = val | (x,val)<-ls; x=lab] subst sub (Tvar n) = hd u, if u~==] = Tvar n, otherwise where u = lookup n sub subst sub (Tcon f ls) = Tcon f (map (subst sub) ls) subst_assoc sub ls = (x,subst …